/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package tesis.controller;


import java.io.IOException;
import java.util.*;
import java.util.logging.Level;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.map.JsonMappingException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import tesis.domain.MapaSincronizado;
import tesis.dto.in.*;
import tesis.dto.util.TipoEstacionEnum;
import tesis.service.*;
import tesis.utils.JSONUtil;

/**
 *
 * @author hectdx
 */
@Controller(value="modeladorController")
@RequestMapping(value="/modelador")
public class ModeladorController {
    
    private final static Logger LOG=LoggerFactory.getLogger(ModeladorController.class);
    
    @Inject
    private MapaSincronizadoService syncService;
    @Inject
    private TipoDatoService tipoDatoService;      
    @Inject
    private CargoService cargoService;
    @Inject 
    private ProcesoService procesoService;
    
    
    @RequestMapping(method= RequestMethod.GET)
    public String init(Model model,  @RequestParam(required=false) Integer idProceso){
        ProcesoDTO procesoDTO=new ProcesoDTO();
        List<MapaSincronizadoDTO>mapasTemp=null;
        String mapasJSON="";
        EstacionDTO estacionDTO=new EstacionDTO();
        LOG.info("Procesando GET  para /modelador");
        try{
            procesoDTO.setIdProceso(idProceso);
            mapasTemp=syncService.findTemporales();
            mapasJSON=JSONUtil.convertObjectToJSON(mapasTemp);
            estacionDTO.setIdTipoEstacion(TipoEstacionEnum.ATENDIBLE.getValue());
            model.addAttribute("estacionDTO",  estacionDTO);
            model.addAttribute("lstCargos", cargoService.findAll());
            model.addAttribute("procesoDTO",  procesoDTO);
            model.addAttribute("componente",  new ComponenteDTO());
            model.addAttribute("mapasJSON", mapasJSON);
        
        }catch (JsonGenerationException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (JsonMappingException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        }
        return "modelador/modelador";
    }
    
    
    @RequestMapping(value="saveTemp",method= RequestMethod.POST)
    @ResponseBody
    public Map saveTemp(HttpServletRequest request, @RequestBody ProcesoDTO procesoDTO){
        Map map=new HashMap();
        String strJSON=null;
            MapaSincronizado mapaSync=new MapaSincronizado();
        LOG.info("Enviando temporal de proceso");
        try {
            strJSON=JSONUtil.convertObjectToJSON(procesoDTO);
            mapaSync.setId(procesoDTO.getIdTemp());
            mapaSync.setFecha(GregorianCalendar.getInstance().getTime());
            mapaSync.setStringData(strJSON);
            mapaSync.setNombre(procesoDTO.getNombre());
            mapaSync.setEstado(procesoDTO.getEstado());
            mapaSync.setLienzo(procesoDTO.getLienzo());
            
            
            //verifica si ya se tiene version instalada
            if (procesoService.esInstalado(procesoDTO.getIdTemp())){
                mapaSync.setId(null);
                map.put("mapaAgregado",false);
            }
            
            mapaSync=syncService.sincronizarTemp(mapaSync);
            
        } catch (JsonGenerationException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (JsonMappingException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        }
        map.put("error", false);
        map.put("id", mapaSync.getId());
        map.put("nombreProceso", mapaSync.getNombre());
        map.put("estado", mapaSync.getEstado());
        return map;
    }
    
     
    @RequestMapping(value="/findTemp",method= RequestMethod.GET)
    @ResponseBody
    public MapaSincronizadoDTO findMapaSincronizado(Model model, @RequestParam Integer id){
          LOG.info("Procesando GET  para /findTemp");
          return syncService.findById(id);
    }
        
        @RequestMapping(value="/crearVariable",method= RequestMethod.GET)
         public String crearVariable(Model model, @RequestParam(required=false) Integer idvariable){
        
        List<TipoDatoDTO> lstTipoDatoDTO = null;    
            
        
        VariableDTO variableDTO=new VariableDTO();
        LOG.info("Procesando GET  para /crear");
        
        lstTipoDatoDTO = tipoDatoService.find(new TipoDatoDTO());
        if (idvariable == null){
           variableDTO.setIdvariable(GregorianCalendar.getInstance().hashCode());
        }
        
        model.addAttribute("lstTipoDatoDTO",lstTipoDatoDTO);
        model.addAttribute("variableDTO", variableDTO);
        return "modelador/variable";
    }
    
        @RequestMapping(value="/crearTipoDocumento",method= RequestMethod.GET)
        public String crearTipoDocumento(Model model,  TipoDocumentoDTO tipoDocumentoDTO){

      
                EstadoDocumentoDTO estadoDocumentoDTO = new EstadoDocumentoDTO();
            estadoDocumentoDTO.setDescripcion("Descripcion");
            estadoDocumentoDTO.setNombre("Nombre");
        
            if(tipoDocumentoDTO.getIdTipoDocumento() == null ){
                tipoDocumentoDTO = new TipoDocumentoDTO();
                tipoDocumentoDTO.setIdTipoDocumento(GregorianCalendar.getInstance().hashCode());
            }
            
            
            LOG.info("Procesando GET  para /crear");
            model.addAttribute("tipoDocumentoDTO", tipoDocumentoDTO);
            model.addAttribute("estadoDocumentoDTO", estadoDocumentoDTO);
            return "modelador/tipoDocumento";
    }
    
    @RequestMapping(value="/crearRegla",method= RequestMethod.GET)
    public String crearRegla(Model model){
        ReglaDTO reglaDTO=new ReglaDTO();
        String reglaJSON=null;
         LOG.info("Procesando GET  para /crearRegla");
        try {
            reglaJSON=JSONUtil.convertObjectToJSON(reglaDTO);
        } catch (JsonGenerationException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (JsonMappingException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            java.util.logging.Logger.getLogger(ModeladorController.class.getName()).log(Level.SEVERE, null, ex);
        }
        
         model.addAttribute("variableDTO", new ParametroVariableDTO());
         model.addAttribute("reglaJSON",reglaJSON);
        return "reglas/regla";
    }
    
    
    @RequestMapping(value="instalarProceso",method= RequestMethod.POST)
    @ResponseBody
    public Map instalarProceso (HttpServletRequest request, @RequestBody ProcesoDTO procesoDTO){
        Map map=new HashMap();
       
        LOG.info("procesando POST para /instalarProceso");
        
            //retiramos el lienzo
            procesoDTO.setVersion(procesoDTO.getIdProceso());//es el id del proceso modelado
            procesoDTO.setLienzo(null);
            procesoDTO.setIdProceso(null);
            procesoDTO.setIdCategoriaProceso(1);//en BD
            
            procesoDTO=procesoService.instalarProceso(procesoDTO);
            if (procesoDTO.isError()){
                map.put("error", true);
                map.put("mensaje",procesoDTO.getMensaje());
                LOG.error("Ocurrio un error: "+procesoDTO.getMensaje());
            }else{
                LOG.info("Proceso instalado correctamente, id: "+procesoDTO.getIdProceso());    
            }

        return map;
    }
    
    @RequestMapping(value="/eliminarModelado",method= RequestMethod.GET)
    @ResponseBody
    public Map eliminarModelado(Model model, @RequestParam Integer id){
          LOG.info("Procesando GET  para /eliminarModelado");
          
          if (procesoService.esInstalado(id)){
              Map map=new HashMap();
              map.put("error","El mapa tiene proceso instalado, no se puede borrar");
              return map;
          }
          
          
          return syncService.eliminarMapa(id);
    }
    
    /*public void crearLstConexiones(ProcesoDTO procesoDTO){
        
        List<ConexionDTO> lstConexionDTO = procesoDTO.getLstConexiones();
        for(ConexionDTO conexionDTO : lstConexionDTO){
            int id = GregorianCalendar.getInstance().hashCode();   
            conexionDTO.setIdConexion(id);
            Conexion conexion = ConvertBeanUtil.convertConexionDTOtoEntity(conexionDTO, procesoDTO.getLstEstaciones());
            conexionService.instalarConexion(conexion);
        }
        
    }
        
    public void crearLstVariables(ProcesoDTO procesoDTO, Proceso proceso){
       
        List<VariableDTO> lstVariablesDTO = procesoDTO.getLstVariables();
        
        for (VariableDTO variableDTO : lstVariablesDTO) {
            int id = GregorianCalendar.getInstance().hashCode();           
            variableDTO.setIdvariable(id);     
            variableDTO.setTipoDatoDTO(tipoDatoService.findByName(variableDTO.getTipoDatoDTO().getNombretipodato()));
            Variable variable = ConvertBeanUtil.convertVariableDTOtoEntity(variableDTO);
            variable.setIdproceso(proceso);
            variableService.intalarVariable(variable);
        }
       
    }
    
       
    public void crearLstTipoDocumentos(ProcesoDTO procesoDTO,Proceso proceso){
        List<TipoDocumentoDTO> lstTipoDocumentoDTO = procesoDTO.getLstDocumentos();
        
        for (TipoDocumentoDTO tipoDocumentoDTO : lstTipoDocumentoDTO) {
            int id = GregorianCalendar.getInstance().hashCode();           
            tipoDocumentoDTO.setIdTipoDocumento(id);
            TipoDocumento tipoDocumento = ConvertBeanUtil.convertTipoDocumentoDTOtoEntity(tipoDocumentoDTO);
            tipoDocumento.setIdproceso(proceso);
            
            tipoDocumentoService.instalarTipoDocumento(tipoDocumento);
            
            crearLstEstadoDocumento(tipoDocumentoDTO.getLstEstadoDocumentoDTO(),tipoDocumento);
            
        
        }
 
    }
    
    
    public void crearLstEstadoDocumento(List<EstadoDocumentoDTO> lstDocumentosDTO,TipoDocumento tipoDocumento){
        for(EstadoDocumentoDTO estadoDTO : lstDocumentosDTO){
            int id = GregorianCalendar.getInstance().hashCode();  
            estadoDTO.setIdestadodocumento(id);
            EstadoDocumento estadoDocumento =  ConvertBeanUtil.convertEstadoDocumentoDTOtoEntity(estadoDTO);
            estadoDocumento.setIdtipodocumento(tipoDocumento);                
            estadoDocumentoService.instalarEstadoDocumento(estadoDocumento);
        }
       
    }
    
    public void crearLstEstaciones(ProcesoDTO procesoDTO, Proceso proceso){

        List<EstacionDTO> lstEstacionesDTO = procesoDTO.getLstEstaciones();
        for(EstacionDTO estacionDTO: lstEstacionesDTO){
            int id = GregorianCalendar.getInstance().hashCode();
            estacionDTO.setIdEstacion(id);
            Estacion estacion = ConvertBeanUtil.convertEstacionDTOtoEntity(estacionDTO);
            estacion.setIdproceso(proceso);
            estacionService.instalarEstacion(estacion);
                
        }

    }
   
    
    */
}
